home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / poplib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  13KB  |  439 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''A POP3 client class.
  5.  
  6. Based on the J. Myers POP3 draft, Jan. 96
  7. '''
  8. import re
  9. import socket
  10. __all__ = [
  11.     'POP3',
  12.     'error_proto',
  13.     'POP3_SSL']
  14.  
  15. class error_proto(Exception):
  16.     pass
  17.  
  18. POP3_PORT = 110
  19. POP3_SSL_PORT = 995
  20. CR = '\r'
  21. LF = '\n'
  22. CRLF = CR + LF
  23.  
  24. class POP3:
  25.     """This class supports both the minimal and optional command sets.
  26.     Arguments can be strings or integers (where appropriate)
  27.     (e.g.: retr(1) and retr('1') both work equally well.
  28.  
  29.     Minimal Command Set:
  30.             USER name               user(name)
  31.             PASS string             pass_(string)
  32.             STAT                    stat()
  33.             LIST [msg]              list(msg = None)
  34.             RETR msg                retr(msg)
  35.             DELE msg                dele(msg)
  36.             NOOP                    noop()
  37.             RSET                    rset()
  38.             QUIT                    quit()
  39.  
  40.     Optional Commands (some servers support these):
  41.             RPOP name               rpop(name)
  42.             APOP name digest        apop(name, digest)
  43.             TOP msg n               top(msg, n)
  44.             UIDL [msg]              uidl(msg = None)
  45.  
  46.     Raises one exception: 'error_proto'.
  47.  
  48.     Instantiate with:
  49.             POP3(hostname, port=110)
  50.  
  51.     NB:     the POP protocol locks the mailbox from user
  52.             authorization until QUIT, so be sure to get in, suck
  53.             the messages, and quit, each time you access the
  54.             mailbox.
  55.  
  56.             POP is a line-based protocol, which means large mail
  57.             messages consume lots of python cycles reading them
  58.             line-by-line.
  59.  
  60.             If it's available on your mail server, use IMAP4
  61.             instead, it doesn't suffer from the two problems
  62.             above.
  63.     """
  64.     
  65.     def __init__(self, host, port = POP3_PORT):
  66.         self.host = host
  67.         self.port = port
  68.         msg = 'getaddrinfo returns an empty list'
  69.         self.sock = None
  70.         for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
  71.             (af, socktype, proto, canonname, sa) = res
  72.             
  73.             try:
  74.                 self.sock = socket.socket(af, socktype, proto)
  75.                 self.sock.connect(sa)
  76.             except socket.error:
  77.                 msg = None
  78.                 if self.sock:
  79.                     self.sock.close()
  80.                 
  81.                 self.sock = None
  82.                 continue
  83.  
  84.             break
  85.         
  86.         if not self.sock:
  87.             raise socket.error, msg
  88.         
  89.         self.file = self.sock.makefile('rb')
  90.         self._debugging = 0
  91.         self.welcome = self._getresp()
  92.  
  93.     
  94.     def _putline(self, line):
  95.         if self._debugging > 1:
  96.             print '*put*', repr(line)
  97.         
  98.         self.sock.sendall('%s%s' % (line, CRLF))
  99.  
  100.     
  101.     def _putcmd(self, line):
  102.         if self._debugging:
  103.             print '*cmd*', repr(line)
  104.         
  105.         self._putline(line)
  106.  
  107.     
  108.     def _getline(self):
  109.         line = self.file.readline()
  110.         if self._debugging > 1:
  111.             print '*get*', repr(line)
  112.         
  113.         if not line:
  114.             raise error_proto('-ERR EOF')
  115.         
  116.         octets = len(line)
  117.         if line[-2:] == CRLF:
  118.             return (line[:-2], octets)
  119.         
  120.         if line[0] == CR:
  121.             return (line[1:-1], octets)
  122.         
  123.         return (line[:-1], octets)
  124.  
  125.     
  126.     def _getresp(self):
  127.         (resp, o) = self._getline()
  128.         if self._debugging > 1:
  129.             print '*resp*', repr(resp)
  130.         
  131.         c = resp[:1]
  132.         if c != '+':
  133.             raise error_proto(resp)
  134.         
  135.         return resp
  136.  
  137.     
  138.     def _getlongresp(self):
  139.         resp = self._getresp()
  140.         list = []
  141.         octets = 0
  142.         (line, o) = self._getline()
  143.         while line != '.':
  144.             if line[:2] == '..':
  145.                 o = o - 1
  146.                 line = line[1:]
  147.             
  148.             octets = octets + o
  149.             list.append(line)
  150.             (line, o) = self._getline()
  151.         return (resp, list, octets)
  152.  
  153.     
  154.     def _shortcmd(self, line):
  155.         self._putcmd(line)
  156.         return self._getresp()
  157.  
  158.     
  159.     def _longcmd(self, line):
  160.         self._putcmd(line)
  161.         return self._getlongresp()
  162.  
  163.     
  164.     def getwelcome(self):
  165.         return self.welcome
  166.  
  167.     
  168.     def set_debuglevel(self, level):
  169.         self._debugging = level
  170.  
  171.     
  172.     def user(self, user):
  173.         '''Send user name, return response
  174.  
  175.         (should indicate password required).
  176.         '''
  177.         return self._shortcmd('USER %s' % user)
  178.  
  179.     
  180.     def pass_(self, pswd):
  181.         """Send password, return response
  182.  
  183.         (response includes message count, mailbox size).
  184.  
  185.         NB: mailbox is locked by server from here to 'quit()'
  186.         """
  187.         return self._shortcmd('PASS %s' % pswd)
  188.  
  189.     
  190.     def stat(self):
  191.         '''Get mailbox status.
  192.  
  193.         Result is tuple of 2 ints (message count, mailbox size)
  194.         '''
  195.         retval = self._shortcmd('STAT')
  196.         rets = retval.split()
  197.         if self._debugging:
  198.             print '*stat*', repr(rets)
  199.         
  200.         numMessages = int(rets[1])
  201.         sizeMessages = int(rets[2])
  202.         return (numMessages, sizeMessages)
  203.  
  204.     
  205.     def list(self, which = None):
  206.         '''Request listing, return result.
  207.  
  208.         Result without a message number argument is in form
  209.         [\'response\', [\'mesg_num octets\', ...], octets].
  210.  
  211.         Result when a message number argument is given is a
  212.         single response: the "scan listing" for that message.
  213.         '''
  214.         if which is not None:
  215.             return self._shortcmd('LIST %s' % which)
  216.         
  217.         return self._longcmd('LIST')
  218.  
  219.     
  220.     def retr(self, which):
  221.         """Retrieve whole message number 'which'.
  222.  
  223.         Result is in form ['response', ['line', ...], octets].
  224.         """
  225.         return self._longcmd('RETR %s' % which)
  226.  
  227.     
  228.     def dele(self, which):
  229.         """Delete message number 'which'.
  230.  
  231.         Result is 'response'.
  232.         """
  233.         return self._shortcmd('DELE %s' % which)
  234.  
  235.     
  236.     def noop(self):
  237.         '''Does nothing.
  238.  
  239.         One supposes the response indicates the server is alive.
  240.         '''
  241.         return self._shortcmd('NOOP')
  242.  
  243.     
  244.     def rset(self):
  245.         '''Not sure what this does.'''
  246.         return self._shortcmd('RSET')
  247.  
  248.     
  249.     def quit(self):
  250.         '''Signoff: commit changes on server, unlock mailbox, close connection.'''
  251.         
  252.         try:
  253.             resp = self._shortcmd('QUIT')
  254.         except error_proto:
  255.             val = None
  256.             resp = val
  257.  
  258.         self.file.close()
  259.         self.sock.close()
  260.         del self.file
  261.         del self.sock
  262.         return resp
  263.  
  264.     
  265.     def rpop(self, user):
  266.         '''Not sure what this does.'''
  267.         return self._shortcmd('RPOP %s' % user)
  268.  
  269.     timestamp = re.compile('\\+OK.*(<[^>]+>)')
  270.     
  271.     def apop(self, user, secret):
  272.         """Authorisation
  273.  
  274.         - only possible if server has supplied a timestamp in initial greeting.
  275.  
  276.         Args:
  277.                 user    - mailbox user;
  278.                 secret  - secret shared between client and server.
  279.  
  280.         NB: mailbox is locked by server from here to 'quit()'
  281.         """
  282.         m = self.timestamp.match(self.welcome)
  283.         if not m:
  284.             raise error_proto('-ERR APOP not supported by server')
  285.         
  286.         import md5 as md5
  287.         digest = md5.new(m.group(1) + secret).digest()
  288.         digest = ''.join(map((lambda x: '%02x' % ord(x)), digest))
  289.         return self._shortcmd('APOP %s %s' % (user, digest))
  290.  
  291.     
  292.     def top(self, which, howmuch):
  293.         """Retrieve message header of message number 'which'
  294.         and first 'howmuch' lines of message body.
  295.  
  296.         Result is in form ['response', ['line', ...], octets].
  297.         """
  298.         return self._longcmd('TOP %s %s' % (which, howmuch))
  299.  
  300.     
  301.     def uidl(self, which = None):
  302.         """Return message digest (unique id) list.
  303.  
  304.         If 'which', result contains unique id for that message
  305.         in the form 'response mesgnum uid', otherwise result is
  306.         the list ['response', ['mesgnum uid', ...], octets]
  307.         """
  308.         if which is not None:
  309.             return self._shortcmd('UIDL %s' % which)
  310.         
  311.         return self._longcmd('UIDL')
  312.  
  313.  
  314.  
  315. class POP3_SSL(POP3):
  316.     '''POP3 client class over SSL connection
  317.  
  318.     Instantiate with: POP3_SSL(hostname, port=995, keyfile=None, certfile=None)
  319.  
  320.            hostname - the hostname of the pop3 over ssl server
  321.            port - port number
  322.            keyfile - PEM formatted file that countains your private key
  323.            certfile - PEM formatted certificate chain file
  324.  
  325.         See the methods of the parent class POP3 for more documentation.
  326.     '''
  327.     
  328.     def __init__(self, host, port = POP3_SSL_PORT, keyfile = None, certfile = None):
  329.         self.host = host
  330.         self.port = port
  331.         self.keyfile = keyfile
  332.         self.certfile = certfile
  333.         self.buffer = ''
  334.         msg = 'getaddrinfo returns an empty list'
  335.         self.sock = None
  336.         for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
  337.             (af, socktype, proto, canonname, sa) = res
  338.             
  339.             try:
  340.                 self.sock = socket.socket(af, socktype, proto)
  341.                 self.sock.connect(sa)
  342.             except socket.error:
  343.                 msg = None
  344.                 if self.sock:
  345.                     self.sock.close()
  346.                 
  347.                 self.sock = None
  348.                 continue
  349.  
  350.             break
  351.         
  352.         if not self.sock:
  353.             raise socket.error, msg
  354.         
  355.         self.file = self.sock.makefile('rb')
  356.         self.sslobj = socket.ssl(self.sock, self.keyfile, self.certfile)
  357.         self._debugging = 0
  358.         self.welcome = self._getresp()
  359.  
  360.     
  361.     def _fillBuffer(self):
  362.         localbuf = self.sslobj.read()
  363.         if len(localbuf) == 0:
  364.             raise error_proto('-ERR EOF')
  365.         
  366.         self.buffer += localbuf
  367.  
  368.     
  369.     def _getline(self):
  370.         line = ''
  371.         renewline = re.compile('.*?\\n')
  372.         match = renewline.match(self.buffer)
  373.         while not match:
  374.             self._fillBuffer()
  375.             match = renewline.match(self.buffer)
  376.         line = match.group(0)
  377.         self.buffer = renewline.sub('', self.buffer, 1)
  378.         if self._debugging > 1:
  379.             print '*get*', repr(line)
  380.         
  381.         octets = len(line)
  382.         if line[-2:] == CRLF:
  383.             return (line[:-2], octets)
  384.         
  385.         if line[0] == CR:
  386.             return (line[1:-1], octets)
  387.         
  388.         return (line[:-1], octets)
  389.  
  390.     
  391.     def _putline(self, line):
  392.         if self._debugging > 1:
  393.             print '*put*', repr(line)
  394.         
  395.         line += CRLF
  396.         bytes = len(line)
  397.         while bytes > 0:
  398.             sent = self.sslobj.write(line)
  399.             if sent == bytes:
  400.                 break
  401.             
  402.             line = line[sent:]
  403.             bytes = bytes - sent
  404.  
  405.     
  406.     def quit(self):
  407.         '''Signoff: commit changes on server, unlock mailbox, close connection.'''
  408.         
  409.         try:
  410.             resp = self._shortcmd('QUIT')
  411.         except error_proto:
  412.             val = None
  413.             resp = val
  414.  
  415.         self.sock.close()
  416.         del self.sslobj
  417.         del self.sock
  418.         return resp
  419.  
  420.  
  421. if __name__ == '__main__':
  422.     import sys
  423.     a = POP3(sys.argv[1])
  424.     print a.getwelcome()
  425.     a.user(sys.argv[2])
  426.     a.pass_(sys.argv[3])
  427.     a.list()
  428.     (numMsgs, totalSize) = a.stat()
  429.     for i in range(1, numMsgs + 1):
  430.         (header, msg, octets) = a.retr(i)
  431.         print 'Message %d:' % i
  432.         for line in msg:
  433.             print '   ' + line
  434.         
  435.         print '-----------------------'
  436.     
  437.     a.quit()
  438.  
  439.